Flutter Shell
介绍
Flutter 引擎中最重要的类。当 embedders 创建 Flutter Application 时，会创建 Shell 实例。
Shell 的创建和销毁都是同步的，embedder 只持有一个 Shell 的指针。
Shell 自己不负责创建线程，由 embedder 负责创建线程，并给 Shell 提供 TaskRunner。
由于 Shell 销毁的确定性，embedder 可以在回收 Shell 之后销毁所有线程。
Shell 必须在同一个线程创建和销毁。
不同的 Shell，如一个 Flutter 应用中的不同实例，可以同时运行在不同线程。
Task Runner 本身不用唯一。如果 Shell 的所有 Task runner 引用在创建时都引用了同一个 Task Runner，Flutter 应用按照单线程运行。
Shell 底下包含许多组件，采用代理模式。
创建 Shell
作为引擎中最重要的类，Shell 的创建堪称重中之重，对应的方法是 Shel::Create。
Shel::Create
std::unique_ptr<Shell> Shell::Create(
const PlatformData& platform_data,
TaskRunners task_runners,
Settings settings,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
bool is_gpu_disabled) {
// 参数初始化
PerformInitializationTasks(settings);
// settings 提供了两个关键设置：vm_snapshot、isolate_snapshot
auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
// 创建 DartVM！！！DartVM 是在这里创建的
auto vm = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);
// 如果 isolate_snapshot 没设置，去 DartVM 的
if (!isolate_snapshot) {
isolate_snapshot = vm->GetVMData()->GetIsolateSnapshot();
}
// 进行下一步创建方法
return CreateWithSnapshot(std::move(platform_data), //
std::move(task_runners), //
std::move(settings), //
std::move(vm), //
std::move(isolate_snapshot), //
std::move(on_create_platform_view), //
std::move(on_create_rasterizer), //
CreateEngine, is_gpu_disabled);
}
其中：
- vm_snapshot：
- isolate_snapshot：
- DartVM 是在这里创建的，别看只是一句话，确把整个 VM 跑起来了！
Shell::CreateWithSnapshot
std::unique_ptr<Shell> Shell::CreateWithSnapshot(
const PlatformData& platform_data,
TaskRunners task_runners,
Settings settings,
DartVMRef vm,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
const Shell::EngineCreateCallback& on_create_engine,
bool is_gpu_disabled) {
// This must come first as it initializes tracing.
PerformInitializationTasks(settings);
fml::AutoResetWaitableEvent latch;
std::unique_ptr<Shell> shell;
// 向 platform taskrunner 抛一个事件，创建 Shell
fml::TaskRunner::RunNowOrPostTask(
task_runners.GetPlatformTaskRunner(),
fml::MakeCopyable(
[&latch, //
&shell, //
task_runners = std::move(task_runners), //
platform_data = std::move(platform_data), //
settings = std::move(settings), //
vm = std::move(vm), //
isolate_snapshot = std::move(isolate_snapshot), //
on_create_platform_view = std::move(on_create_platform_view), //
on_create_rasterizer = std::move(on_create_rasterizer), //
on_create_engine = std::move(on_create_engine),
is_gpu_disabled]() mutable {
// 上面都是参数，实际内容在这里
shell = CreateShellOnPlatformThread(
std::move(vm), //
std::move(task_runners), //
std::move(platform_data), //
std::move(settings), //
std::move(isolate_snapshot), //
std::move(on_create_platform_view), //
std::move(on_create_rasterizer), //
std::move(on_create_engine), is_gpu_disabled);
latch.Signal();
}));
// shell 的创建会锁主线程
latch.Wait();
return shell;
}
这一步主要是向 Platform 上调度了一个任务，具体的创建方法是 CreateShellOnPlatformThread。
Shell::CreateShellOnPlatformThread
这一步非常复杂，因此拆开来看。首先方法签名：
std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
DartVMRef vm,
TaskRunners task_runners,
const PlatformData& platform_data,
Settings settings,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
const Shell::EngineCreateCallback& on_create_engine,
bool is_gpu_disabled) {
一上来就创建了 Shell 实例，关于 Shell 的构造函数，放到后续小节再看，这里就当作黑盒，实例创建好了：
auto shell = std::unique_ptr<Shell>(
new Shell(std::move(vm), task_runners, settings,
std::make_shared<VolatilePathTracker>(
task_runners.GetUITaskRunner(),
!settings.skia_deterministic_rendering_on_cpu),
is_gpu_disabled));
shell 除了构造方法之外，有一个 Setup 方法，只有 Setup 也调完了，Shell 才能初始化成功。
由于 Shell 的创建涉及到好多个线程，因此接下来的逻辑当中，会创建很多 Promise，进行多线程并行初始化。
Raster 初始化，运行再 Raster 线程：
std::promise<std::unique_ptr<Rasterizer>> rasterizer_promise;
auto rasterizer_future = rasterizer_promise.get_future();
std::promise<fml::WeakPtr<SnapshotDelegate>> snapshot_delegate_promise;
auto snapshot_delegate_future = snapshot_delegate_promise.get_future();
fml::TaskRunner::RunNowOrPostTask(
task_runners.GetRasterTaskRunner(), [&rasterizer_promise, //
&snapshot_delegate_promise,
on_create_rasterizer, //
shell = shell.get() //
]() {
TRACE_EVENT0("flutter", "ShellSetupGPUSubsystem");
std::unique_ptr<Rasterizer> rasterizer(on_create_rasterizer(*shell));
snapshot_delegate_promise.set_value(rasterizer->GetSnapshotDelegate());
rasterizer_promise.set_value(std::move(rasterizer));
});
创建 PlatformView：
auto platform_view = on_create_platform_view(*shell.get());
if (!platform_view || !platform_view->GetWeakPtr()) {
return nullptr;
}
创建 vsync 同步器：
auto vsync_waiter = platform_view->CreateVSyncWaiter();
if (!vsync_waiter) {
return nullptr;
}
IO 线程初始化：
std::promise<std::unique_ptr<ShellIOManager>> io_manager_promise;
auto io_manager_future = io_manager_promise.get_future();
std::promise<fml::WeakPtr<ShellIOManager>> weak_io_manager_promise;
auto weak_io_manager_future = weak_io_manager_promise.get_future();
std::promise<fml::RefPtr<SkiaUnrefQueue>> unref_queue_promise;
auto unref_queue_future = unref_queue_promise.get_future();
auto io_task_runner = shell->GetTaskRunners().GetIOTaskRunner();
fml::TaskRunner::RunNowOrPostTask(
io_task_runner,
[&io_manager_promise, //
&weak_io_manager_promise, //
&unref_queue_promise, //
platform_view = platform_view->GetWeakPtr(), //
io_task_runner, //
is_backgrounded_sync_switch = shell->GetIsGpuDisabledSyncSwitch() //
]() {
TRACE_EVENT0("flutter", "ShellSetupIOSubsystem");
auto io_manager = std::make_unique<ShellIOManager>(
platform_view.getUnsafe()->CreateResourceContext(),
is_backgrounded_sync_switch, io_task_runner);
weak_io_manager_promise.set_value(io_manager->GetWeakPtr());
unref_queue_promise.set_value(io_manager->GetSkiaUnrefQueue());
io_manager_promise.set_value(std::move(io_manager));
});
创建 GetDispatcherMaker：
auto dispatcher_maker = platform_view->GetDispatcherMaker();
创建 Flutter Engine：
std::promise<std::unique_ptr<Engine>> engine_promise;
auto engine_future = engine_promise.get_future();
fml::TaskRunner::RunNowOrPostTask(
shell->GetTaskRunners().GetUITaskRunner(),
fml::MakeCopyable([&engine_promise, //
shell = shell.get(), //
&dispatcher_maker, //
&platform_data, //
isolate_snapshot = std::move(isolate_snapshot), //
vsync_waiter = std::move(vsync_waiter), //
&weak_io_manager_future, //
&snapshot_delegate_future, //
&unref_queue_future, //
&on_create_engine]() mutable {
TRACE_EVENT0("flutter", "ShellSetupUISubsystem");
const auto& task_runners = shell->GetTaskRunners();
// The animator is owned by the UI thread but it gets its vsync pulses
// from the platform.
auto animator = std::make_unique<Animator>(*shell, task_runners,
std::move(vsync_waiter));
engine_promise.set_value(
on_create_engine(*shell, //
dispatcher_maker, //
*shell->GetDartVM(), //
std::move(isolate_snapshot), //
task_runners, //
platform_data, //
shell->GetSettings(), //
std::move(animator), //
weak_io_manager_future.get(), //
unref_queue_future.get(), //
snapshot_delegate_future.get(), //
shell->volatile_path_tracker_));
}));
最后对 Shell 进行设置：
if (!shell->Setup(std::move(platform_view), //
engine_future.get(), //
rasterizer_future.get(), //
io_manager_future.get()) //
) {
return nullptr;
}
return shell;